const express = require('express');
const router = express.Router();

// 标签相关的API路由
function setupLabelRoutes(pool) {
  // 获取所有标签
  router.get('/api/labels', async (req, res) => {
    try {
      const { config_id } = req.query;
      
      let query = `
        SELECT 
          l.id,
          l.label_id, 
          l.label_text, 
          l.config_id,
          c.config_name
        FROM Labels l
        LEFT JOIN Configs c ON l.config_id = c.id
      `;
      
      let queryParams = [];
      
      if (config_id) {
        query += ` WHERE l.config_id = $1`;
        queryParams.push(config_id);
      }
      
      query += ` ORDER BY l.label_id`;
      
      const result = await pool.query(query, queryParams);
      res.json(result.rows);
    } catch (error) {
      console.error('获取标签列表错误:', error);
      res.status(500).json({ error: '获取标签列表失败' });
    }
  });
  
  // 创建标签
  router.post('/api/labels', async (req, res) => {
    console.log('接收到 /api/labels POST 请求');
    console.log('请求体内容:', req.body);
    try {
      const { label_id, label_name, config_id } = req.body;
      
      if (!label_name || typeof label_name !== 'string' || label_name.trim() === '') {
        return res.status(400).json({ error: '标签名称不能为空' });
      }
      
      if (!config_id || typeof config_id !== 'string' || config_id.trim() === '') {
        return res.status(400).json({ error: '配置代码不能为空' });
      }
      
      // let newLabelId;
      // // 如果请求中提供了label_id，则使用它；否则自动生成
      // if (label_id !== undefined && typeof label_id === 'number') {
      //   // 检查提供的label_id是否已存在
      //   const idExists = await pool.query('SELECT * FROM Labels WHERE label_id = $1', [label_id]);
      //   if (idExists.rows.length > 0) {
      //     return res.status(400).json({ error: '标签ID已存在' });
      //   }
      //   newLabelId = label_id;
      // } else {
      //   // 获取当前最大的label_id值，加1作为新标签的label_id
      //   const maxLabelIdResult = await pool.query('SELECT MAX(label_id) as max_id FROM Labels');
      //   newLabelId = (maxLabelIdResult.rows[0].max_id || 0) + 1;
      // }
      // 检查标签ID是否已存在（相同名称和配置ID）
      const labelIDExists = await pool.query('SELECT * FROM Labels WHERE label_id = $1 AND config_id = $2', [label_id, config_id.trim()]);
      if (labelIDExists.rows.length > 0) {
        return res.status(400).json({ error: '标签ID已存在' });
      }
      
      // 检查标签是否已存在（相同名称和配置ID）
      const labelExists = await pool.query('SELECT * FROM Labels WHERE label_text = $1 AND config_id = $2', [label_name.trim(), config_id.trim()]);
      if (labelExists.rows.length > 0) {
        return res.status(400).json({ error: '标签已存在' });
      }
      
      // 插入新标签，显式提供label_id
      const result = await pool.query('INSERT INTO Labels (label_id, label_text, config_id) VALUES ($1, $2, $3) RETURNING id, label_text, config_id', 
        [label_id, label_name.trim(), config_id.trim()]);
      
      res.status(201).json({ 
        message: '标签创建成功', 
        label: result.rows[0] 
      });
    } catch (error) {
      console.error('创建标签错误:', error.message);
      console.error('错误详情:', error);
      res.status(500).json({ 
        error: '创建标签失败',
        details: error.message, 
        timestamp: new Date().toISOString()
      });
    }
  });

  // 更新标签
  router.put('/api/labels/:label_id', async (req, res) => {
    console.log('接收到 /api/labels PUT 请求');
    try {
      const { label_id } = req.params;
      const { label_name, config_id } = req.body;
      
      if (!label_name || typeof label_name !== 'string' || label_name.trim() === '') {
        return res.status(400).json({ error: '标签名称不能为空' });
      }
      
      if (!config_id || typeof config_id !== 'string' || config_id.trim() === '') {
        return res.status(400).json({ error: '配置代码不能为空' });
      }
      
      // 检查标签是否存在
      const labelExists = await pool.query('SELECT * FROM Labels WHERE label_id = $1', [label_id]);
      if (labelExists.rows.length === 0) {
        return res.status(404).json({ error: '标签不存在' });
      }
      
      // 检查新标签是否已存在（不同ID但相同名称和配置ID）
      const newLabelExists = await pool.query('SELECT * FROM Labels WHERE label_text = $1 AND config_id = $2 AND label_id != $3', [label_name.trim(), config_id.trim(), label_id]);
      if (newLabelExists.rows.length > 0) {
        return res.status(400).json({ error: '相同配置代码下的标签名称已存在' });
      }
      
      
      // 事务处理：更新标签
      const client = await pool.connect();
      try {
        await client.query('BEGIN');
        
        // 更新Labels表中的标签，包含label_text和config_id
        await client.query('UPDATE Labels SET label_text = $1, config_id = $2 WHERE label_id = $3', [label_name.trim(), config_id.trim(), label_id]);
        
        // 注意：实际应用中可能需要同时更新引用该标签的其他表
        // 例如：Videos表中的object_labels字段
        
        await client.query('COMMIT');
        
        // 获取更新后的标签信息
        const updatedLabel = await pool.query('SELECT label_id, label_text, config_id FROM Labels WHERE label_id = $1', [label_id]);
        
        res.json({ 
          message: '标签更新成功', 
          label: updatedLabel.rows[0] 
        });
      } catch (transactionError) {
        await client.query('ROLLBACK');
        throw transactionError;
      } finally {
        client.release();
      }
    } catch (error) {
      console.error('更新标签错误:', error);
      res.status(500).json({ error: '更新标签失败' });
    }
  });

  // 删除标签
  router.delete('/api/labels/:id', async (req, res) => {
    console.log('接收到 /api/labels DELETE 请求');
    try {
      const { id } = req.params;
      
      // 检查标签是否存在
      const labelExists = await pool.query('SELECT * FROM Labels WHERE id = $1', [id]);
      if (labelExists.rows.length === 0) {
        return res.status(404).json({ error: '标签不存在' });
      }
      
      // 事务处理：删除标签
      const client = await pool.connect();
      try {
        await client.query('BEGIN');
        
        // 注意：实际应用中可能需要先处理引用该标签的其他表
        // 例如：Videos表中的object_labels字段
        
        // 删除标签
        await client.query('DELETE FROM Labels WHERE id = $1', [id]);
        
        await client.query('COMMIT');
        
        res.json({ 
          message: '标签删除成功', 
          id: id 
        });
      } catch (transactionError) {
        await client.query('ROLLBACK');
        throw transactionError;
      } finally {
        client.release();
      }
    } catch (error) {
      console.error('删除标签错误:', error);
      res.status(500).json({ error: '删除标签失败' });
    }
  });

  // 更新标签ID（通过删除旧标签并创建新标签实现）
  router.post('/api/labels/change-id', async (req, res) => {
    console.log('接收到 /api/labels/change-id POST 请求');
    try {
      const { old_label_id, new_label_id, label_name, config_id } = req.body;
      
      // 参数验证
      if (!old_label_id || typeof old_label_id !== 'number') {
        return res.status(400).json({ error: '旧标签ID不能为空且必须是数字' });
      }
      
      if (!new_label_id || typeof new_label_id !== 'number') {
        return res.status(400).json({ error: '新标签ID不能为空且必须是数字' });
      }
      
      if (old_label_id === new_label_id) {
        return res.status(400).json({ error: '新标签ID不能与旧标签ID相同' });
      }
      
      if (!label_name || typeof label_name !== 'string' || label_name.trim() === '') {
        return res.status(400).json({ error: '标签名称不能为空' });
      }
      
      if (!config_id || typeof config_id !== 'string' || config_id.trim() === '') {
        return res.status(400).json({ error: '配置代码不能为空' });
      }
      
      // 事务处理：删除旧标签并创建新标签
      const client = await pool.connect();
      try {
        await client.query('BEGIN');
        
        // 检查旧标签是否存在
        const oldLabelExists = await client.query('SELECT * FROM Labels WHERE label_id = $1', [old_label_id]);
        if (oldLabelExists.rows.length === 0) {
          await client.query('ROLLBACK');
          return res.status(404).json({ error: '旧标签不存在' });
        }
        
        // 检查新标签ID是否已存在
        const newLabelExists = await client.query('SELECT * FROM Labels WHERE label_id = $1', [new_label_id]);
        if (newLabelExists.rows.length > 0) {
          await client.query('ROLLBACK');
          return res.status(400).json({ error: '新标签ID已存在' });
        }
        
        // TODO: 检查是否有其他表引用了旧标签（如Videos表的object_labels字段）
        // 如果有引用，可能需要先更新这些引用
        
        // 删除旧标签
        await client.query('DELETE FROM Labels WHERE label_id = $1', [old_label_id]);
        
        // 创建具有新ID的标签
        await client.query('INSERT INTO Labels (label_id, label_text, config_id) VALUES ($1, $2, $3)', 
          [new_label_id, label_name.trim(), config_id.trim()]);
        
        await client.query('COMMIT');
        
        // 获取新创建的标签信息
        const newLabel = await pool.query('SELECT label_id, label_text, config_id FROM Labels WHERE label_id = $1', [new_label_id]);
        
        res.json({
          message: '标签ID更新成功',
          label: newLabel.rows[0]
        });
      } catch (transactionError) {
        await client.query('ROLLBACK');
        console.error('更新标签ID事务错误:', transactionError);
        throw transactionError;
      } finally {
        client.release();
      }
    } catch (error) {
      console.error('更新标签ID错误:', error);
      res.status(500).json({ error: '更新标签ID失败' });
    }
  });

  return router;
}

module.exports = setupLabelRoutes;